'Weak Dependency Graph [60.0]'
------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ a(c(d(x))) -> c(x)
, u(b(d(d(x)))) -> b(x)
, v(a(a(x))) -> u(v(x))
, v(a(c(x))) -> u(b(d(x)))
, v(c(x)) -> b(x)
, w(a(a(x))) -> u(w(x))
, w(a(c(x))) -> u(b(d(x)))
, w(c(x)) -> b(x)}
Details:
We have computed the following set of weak (innermost) dependency pairs:
{ a^#(c(d(x))) -> c_0()
, u^#(b(d(d(x)))) -> c_1()
, v^#(a(a(x))) -> c_2(u^#(v(x)))
, v^#(a(c(x))) -> c_3(u^#(b(d(x))))
, v^#(c(x)) -> c_4()
, w^#(a(a(x))) -> c_5(u^#(w(x)))
, w^#(a(c(x))) -> c_6(u^#(b(d(x))))
, w^#(c(x)) -> c_7()}
The usable rules are:
{ v(a(a(x))) -> u(v(x))
, v(a(c(x))) -> u(b(d(x)))
, v(c(x)) -> b(x)
, w(a(a(x))) -> u(w(x))
, w(a(c(x))) -> u(b(d(x)))
, w(c(x)) -> b(x)
, u(b(d(d(x)))) -> b(x)}
The estimated dependency graph contains the following edges:
{v^#(a(a(x))) -> c_2(u^#(v(x)))}
==> {u^#(b(d(d(x)))) -> c_1()}
{v^#(a(c(x))) -> c_3(u^#(b(d(x))))}
==> {u^#(b(d(d(x)))) -> c_1()}
{w^#(a(a(x))) -> c_5(u^#(w(x)))}
==> {u^#(b(d(d(x)))) -> c_1()}
{w^#(a(c(x))) -> c_6(u^#(b(d(x))))}
==> {u^#(b(d(d(x)))) -> c_1()}
We consider the following path(s):
1) { v^#(a(a(x))) -> c_2(u^#(v(x)))
, u^#(b(d(d(x)))) -> c_1()}
The usable rules for this path are the following:
{ v(a(a(x))) -> u(v(x))
, v(a(c(x))) -> u(b(d(x)))
, v(c(x)) -> b(x)
, u(b(d(d(x)))) -> b(x)}
We have oriented the usable rules with the following strongly linear interpretation:
Interpretation Functions:
a(x1) = [1] x1 + [14]
c(x1) = [1] x1 + [12]
d(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [1]
v(x1) = [1] x1 + [0]
w(x1) = [0] x1 + [0]
a^#(x1) = [0] x1 + [0]
c_0() = [0]
u^#(x1) = [0] x1 + [0]
c_1() = [0]
v^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4() = [0]
w^#(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7() = [0]
We have applied the subprocessor on the resulting DP-problem:
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {u^#(b(d(d(x)))) -> c_1()}
Weak Rules:
{ v(a(a(x))) -> u(v(x))
, v(a(c(x))) -> u(b(d(x)))
, v(c(x)) -> b(x)
, u(b(d(d(x)))) -> b(x)
, v^#(a(a(x))) -> c_2(u^#(v(x)))}
Details:
We apply the weight gap principle, strictly orienting the rules
{u^#(b(d(d(x)))) -> c_1()}
and weakly orienting the rules
{ v(a(a(x))) -> u(v(x))
, v(a(c(x))) -> u(b(d(x)))
, v(c(x)) -> b(x)
, u(b(d(d(x)))) -> b(x)
, v^#(a(a(x))) -> c_2(u^#(v(x)))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{u^#(b(d(d(x)))) -> c_1()}
Details:
Interpretation Functions:
a(x1) = [1] x1 + [0]
c(x1) = [1] x1 + [0]
d(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
v(x1) = [1] x1 + [1]
w(x1) = [0] x1 + [0]
a^#(x1) = [0] x1 + [0]
c_0() = [0]
u^#(x1) = [1] x1 + [1]
c_1() = [0]
v^#(x1) = [1] x1 + [9]
c_2(x1) = [1] x1 + [7]
c_3(x1) = [0] x1 + [0]
c_4() = [0]
w^#(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
'Empty TRS'
-----------
Answer: YES(?,O(1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {}
Weak Rules:
{ u^#(b(d(d(x)))) -> c_1()
, v(a(a(x))) -> u(v(x))
, v(a(c(x))) -> u(b(d(x)))
, v(c(x)) -> b(x)
, u(b(d(d(x)))) -> b(x)
, v^#(a(a(x))) -> c_2(u^#(v(x)))}
Details:
The given problem does not contain any strict rules
2) { w^#(a(a(x))) -> c_5(u^#(w(x)))
, u^#(b(d(d(x)))) -> c_1()}
The usable rules for this path are the following:
{ w(a(a(x))) -> u(w(x))
, w(a(c(x))) -> u(b(d(x)))
, w(c(x)) -> b(x)
, u(b(d(d(x)))) -> b(x)}
We have oriented the usable rules with the following strongly linear interpretation:
Interpretation Functions:
a(x1) = [1] x1 + [14]
c(x1) = [1] x1 + [12]
d(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [1]
v(x1) = [0] x1 + [0]
w(x1) = [1] x1 + [0]
a^#(x1) = [0] x1 + [0]
c_0() = [0]
u^#(x1) = [0] x1 + [0]
c_1() = [0]
v^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4() = [0]
w^#(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7() = [0]
We have applied the subprocessor on the resulting DP-problem:
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {u^#(b(d(d(x)))) -> c_1()}
Weak Rules:
{ w(a(a(x))) -> u(w(x))
, w(a(c(x))) -> u(b(d(x)))
, w(c(x)) -> b(x)
, u(b(d(d(x)))) -> b(x)
, w^#(a(a(x))) -> c_5(u^#(w(x)))}
Details:
We apply the weight gap principle, strictly orienting the rules
{u^#(b(d(d(x)))) -> c_1()}
and weakly orienting the rules
{ w(a(a(x))) -> u(w(x))
, w(a(c(x))) -> u(b(d(x)))
, w(c(x)) -> b(x)
, u(b(d(d(x)))) -> b(x)
, w^#(a(a(x))) -> c_5(u^#(w(x)))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{u^#(b(d(d(x)))) -> c_1()}
Details:
Interpretation Functions:
a(x1) = [1] x1 + [0]
c(x1) = [1] x1 + [0]
d(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
v(x1) = [0] x1 + [0]
w(x1) = [1] x1 + [1]
a^#(x1) = [0] x1 + [0]
c_0() = [0]
u^#(x1) = [1] x1 + [1]
c_1() = [0]
v^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4() = [0]
w^#(x1) = [1] x1 + [9]
c_5(x1) = [1] x1 + [7]
c_6(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
'Empty TRS'
-----------
Answer: YES(?,O(1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {}
Weak Rules:
{ u^#(b(d(d(x)))) -> c_1()
, w(a(a(x))) -> u(w(x))
, w(a(c(x))) -> u(b(d(x)))
, w(c(x)) -> b(x)
, u(b(d(d(x)))) -> b(x)
, w^#(a(a(x))) -> c_5(u^#(w(x)))}
Details:
The given problem does not contain any strict rules
3) {w^#(a(a(x))) -> c_5(u^#(w(x)))}
The usable rules for this path are the following:
{ w(a(a(x))) -> u(w(x))
, w(a(c(x))) -> u(b(d(x)))
, w(c(x)) -> b(x)
, u(b(d(d(x)))) -> b(x)}
We have oriented the usable rules with the following strongly linear interpretation:
Interpretation Functions:
a(x1) = [1] x1 + [14]
c(x1) = [1] x1 + [12]
d(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [1]
v(x1) = [0] x1 + [0]
w(x1) = [1] x1 + [0]
a^#(x1) = [0] x1 + [0]
c_0() = [0]
u^#(x1) = [0] x1 + [0]
c_1() = [0]
v^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4() = [0]
w^#(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7() = [0]
We have applied the subprocessor on the resulting DP-problem:
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {w^#(a(a(x))) -> c_5(u^#(w(x)))}
Weak Rules:
{ w(a(a(x))) -> u(w(x))
, w(a(c(x))) -> u(b(d(x)))
, w(c(x)) -> b(x)
, u(b(d(d(x)))) -> b(x)}
Details:
We apply the weight gap principle, strictly orienting the rules
{w^#(a(a(x))) -> c_5(u^#(w(x)))}
and weakly orienting the rules
{ w(a(a(x))) -> u(w(x))
, w(a(c(x))) -> u(b(d(x)))
, w(c(x)) -> b(x)
, u(b(d(d(x)))) -> b(x)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{w^#(a(a(x))) -> c_5(u^#(w(x)))}
Details:
Interpretation Functions:
a(x1) = [1] x1 + [0]
c(x1) = [1] x1 + [4]
d(x1) = [1] x1 + [4]
u(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
v(x1) = [0] x1 + [0]
w(x1) = [1] x1 + [0]
a^#(x1) = [0] x1 + [0]
c_0() = [0]
u^#(x1) = [1] x1 + [0]
c_1() = [0]
v^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4() = [0]
w^#(x1) = [1] x1 + [1]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
'Empty TRS'
-----------
Answer: YES(?,O(1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {}
Weak Rules:
{ w^#(a(a(x))) -> c_5(u^#(w(x)))
, w(a(a(x))) -> u(w(x))
, w(a(c(x))) -> u(b(d(x)))
, w(c(x)) -> b(x)
, u(b(d(d(x)))) -> b(x)}
Details:
The given problem does not contain any strict rules
4) {v^#(a(a(x))) -> c_2(u^#(v(x)))}
The usable rules for this path are the following:
{ v(a(a(x))) -> u(v(x))
, v(a(c(x))) -> u(b(d(x)))
, v(c(x)) -> b(x)
, u(b(d(d(x)))) -> b(x)}
We have oriented the usable rules with the following strongly linear interpretation:
Interpretation Functions:
a(x1) = [1] x1 + [14]
c(x1) = [1] x1 + [12]
d(x1) = [1] x1 + [0]
u(x1) = [1] x1 + [1]
b(x1) = [1] x1 + [1]
v(x1) = [1] x1 + [0]
w(x1) = [0] x1 + [0]
a^#(x1) = [0] x1 + [0]
c_0() = [0]
u^#(x1) = [0] x1 + [0]
c_1() = [0]
v^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4() = [0]
w^#(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7() = [0]
We have applied the subprocessor on the resulting DP-problem:
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {v^#(a(a(x))) -> c_2(u^#(v(x)))}
Weak Rules:
{ v(a(a(x))) -> u(v(x))
, v(a(c(x))) -> u(b(d(x)))
, v(c(x)) -> b(x)
, u(b(d(d(x)))) -> b(x)}
Details:
We apply the weight gap principle, strictly orienting the rules
{v^#(a(a(x))) -> c_2(u^#(v(x)))}
and weakly orienting the rules
{ v(a(a(x))) -> u(v(x))
, v(a(c(x))) -> u(b(d(x)))
, v(c(x)) -> b(x)
, u(b(d(d(x)))) -> b(x)}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{v^#(a(a(x))) -> c_2(u^#(v(x)))}
Details:
Interpretation Functions:
a(x1) = [1] x1 + [0]
c(x1) = [1] x1 + [4]
d(x1) = [1] x1 + [4]
u(x1) = [1] x1 + [0]
b(x1) = [1] x1 + [0]
v(x1) = [1] x1 + [0]
w(x1) = [0] x1 + [0]
a^#(x1) = [0] x1 + [0]
c_0() = [0]
u^#(x1) = [1] x1 + [0]
c_1() = [0]
v^#(x1) = [1] x1 + [1]
c_2(x1) = [1] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4() = [0]
w^#(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
'Empty TRS'
-----------
Answer: YES(?,O(1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {}
Weak Rules:
{ v^#(a(a(x))) -> c_2(u^#(v(x)))
, v(a(a(x))) -> u(v(x))
, v(a(c(x))) -> u(b(d(x)))
, v(c(x)) -> b(x)
, u(b(d(d(x)))) -> b(x)}
Details:
The given problem does not contain any strict rules
5) { v^#(a(c(x))) -> c_3(u^#(b(d(x))))
, u^#(b(d(d(x)))) -> c_1()}
The usable rules for this path are empty.
We have oriented the usable rules with the following strongly linear interpretation:
Interpretation Functions:
a(x1) = [0] x1 + [0]
c(x1) = [0] x1 + [0]
d(x1) = [0] x1 + [0]
u(x1) = [0] x1 + [0]
b(x1) = [0] x1 + [0]
v(x1) = [0] x1 + [0]
w(x1) = [0] x1 + [0]
a^#(x1) = [0] x1 + [0]
c_0() = [0]
u^#(x1) = [0] x1 + [0]
c_1() = [0]
v^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4() = [0]
w^#(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7() = [0]
We have applied the subprocessor on the resulting DP-problem:
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {u^#(b(d(d(x)))) -> c_1()}
Weak Rules: {v^#(a(c(x))) -> c_3(u^#(b(d(x))))}
Details:
We apply the weight gap principle, strictly orienting the rules
{u^#(b(d(d(x)))) -> c_1()}
and weakly orienting the rules
{v^#(a(c(x))) -> c_3(u^#(b(d(x))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{u^#(b(d(d(x)))) -> c_1()}
Details:
Interpretation Functions:
a(x1) = [1] x1 + [0]
c(x1) = [1] x1 + [0]
d(x1) = [1] x1 + [0]
u(x1) = [0] x1 + [0]
b(x1) = [1] x1 + [0]
v(x1) = [0] x1 + [0]
w(x1) = [0] x1 + [0]
a^#(x1) = [0] x1 + [0]
c_0() = [0]
u^#(x1) = [1] x1 + [1]
c_1() = [0]
v^#(x1) = [1] x1 + [1]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [0]
c_4() = [0]
w^#(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
'Empty TRS'
-----------
Answer: YES(?,O(1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {}
Weak Rules:
{ u^#(b(d(d(x)))) -> c_1()
, v^#(a(c(x))) -> c_3(u^#(b(d(x))))}
Details:
The given problem does not contain any strict rules
6) { w^#(a(c(x))) -> c_6(u^#(b(d(x))))
, u^#(b(d(d(x)))) -> c_1()}
The usable rules for this path are empty.
We have oriented the usable rules with the following strongly linear interpretation:
Interpretation Functions:
a(x1) = [0] x1 + [0]
c(x1) = [0] x1 + [0]
d(x1) = [0] x1 + [0]
u(x1) = [0] x1 + [0]
b(x1) = [0] x1 + [0]
v(x1) = [0] x1 + [0]
w(x1) = [0] x1 + [0]
a^#(x1) = [0] x1 + [0]
c_0() = [0]
u^#(x1) = [0] x1 + [0]
c_1() = [0]
v^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4() = [0]
w^#(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7() = [0]
We have applied the subprocessor on the resulting DP-problem:
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {u^#(b(d(d(x)))) -> c_1()}
Weak Rules: {w^#(a(c(x))) -> c_6(u^#(b(d(x))))}
Details:
We apply the weight gap principle, strictly orienting the rules
{u^#(b(d(d(x)))) -> c_1()}
and weakly orienting the rules
{w^#(a(c(x))) -> c_6(u^#(b(d(x))))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{u^#(b(d(d(x)))) -> c_1()}
Details:
Interpretation Functions:
a(x1) = [1] x1 + [0]
c(x1) = [1] x1 + [0]
d(x1) = [1] x1 + [0]
u(x1) = [0] x1 + [0]
b(x1) = [1] x1 + [0]
v(x1) = [0] x1 + [0]
w(x1) = [0] x1 + [0]
a^#(x1) = [0] x1 + [0]
c_0() = [0]
u^#(x1) = [1] x1 + [1]
c_1() = [0]
v^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4() = [0]
w^#(x1) = [1] x1 + [1]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
'Empty TRS'
-----------
Answer: YES(?,O(1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {}
Weak Rules:
{ u^#(b(d(d(x)))) -> c_1()
, w^#(a(c(x))) -> c_6(u^#(b(d(x))))}
Details:
The given problem does not contain any strict rules
7) {v^#(a(c(x))) -> c_3(u^#(b(d(x))))}
The usable rules for this path are empty.
We have oriented the usable rules with the following strongly linear interpretation:
Interpretation Functions:
a(x1) = [0] x1 + [0]
c(x1) = [0] x1 + [0]
d(x1) = [0] x1 + [0]
u(x1) = [0] x1 + [0]
b(x1) = [0] x1 + [0]
v(x1) = [0] x1 + [0]
w(x1) = [0] x1 + [0]
a^#(x1) = [0] x1 + [0]
c_0() = [0]
u^#(x1) = [0] x1 + [0]
c_1() = [0]
v^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4() = [0]
w^#(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7() = [0]
We have applied the subprocessor on the resulting DP-problem:
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {v^#(a(c(x))) -> c_3(u^#(b(d(x))))}
Weak Rules: {}
Details:
We apply the weight gap principle, strictly orienting the rules
{v^#(a(c(x))) -> c_3(u^#(b(d(x))))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{v^#(a(c(x))) -> c_3(u^#(b(d(x))))}
Details:
Interpretation Functions:
a(x1) = [1] x1 + [0]
c(x1) = [1] x1 + [0]
d(x1) = [1] x1 + [0]
u(x1) = [0] x1 + [0]
b(x1) = [1] x1 + [0]
v(x1) = [0] x1 + [0]
w(x1) = [0] x1 + [0]
a^#(x1) = [0] x1 + [0]
c_0() = [0]
u^#(x1) = [1] x1 + [0]
c_1() = [0]
v^#(x1) = [1] x1 + [1]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [1] x1 + [0]
c_4() = [0]
w^#(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
'Empty TRS'
-----------
Answer: YES(?,O(1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {}
Weak Rules: {v^#(a(c(x))) -> c_3(u^#(b(d(x))))}
Details:
The given problem does not contain any strict rules
8) {w^#(a(c(x))) -> c_6(u^#(b(d(x))))}
The usable rules for this path are empty.
We have oriented the usable rules with the following strongly linear interpretation:
Interpretation Functions:
a(x1) = [0] x1 + [0]
c(x1) = [0] x1 + [0]
d(x1) = [0] x1 + [0]
u(x1) = [0] x1 + [0]
b(x1) = [0] x1 + [0]
v(x1) = [0] x1 + [0]
w(x1) = [0] x1 + [0]
a^#(x1) = [0] x1 + [0]
c_0() = [0]
u^#(x1) = [0] x1 + [0]
c_1() = [0]
v^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4() = [0]
w^#(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7() = [0]
We have applied the subprocessor on the resulting DP-problem:
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {w^#(a(c(x))) -> c_6(u^#(b(d(x))))}
Weak Rules: {}
Details:
We apply the weight gap principle, strictly orienting the rules
{w^#(a(c(x))) -> c_6(u^#(b(d(x))))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{w^#(a(c(x))) -> c_6(u^#(b(d(x))))}
Details:
Interpretation Functions:
a(x1) = [1] x1 + [0]
c(x1) = [1] x1 + [0]
d(x1) = [1] x1 + [0]
u(x1) = [0] x1 + [0]
b(x1) = [1] x1 + [0]
v(x1) = [0] x1 + [0]
w(x1) = [0] x1 + [0]
a^#(x1) = [0] x1 + [0]
c_0() = [0]
u^#(x1) = [1] x1 + [0]
c_1() = [0]
v^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4() = [0]
w^#(x1) = [1] x1 + [1]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
'Empty TRS'
-----------
Answer: YES(?,O(1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {}
Weak Rules: {w^#(a(c(x))) -> c_6(u^#(b(d(x))))}
Details:
The given problem does not contain any strict rules
9) {a^#(c(d(x))) -> c_0()}
The usable rules for this path are empty.
We have oriented the usable rules with the following strongly linear interpretation:
Interpretation Functions:
a(x1) = [0] x1 + [0]
c(x1) = [0] x1 + [0]
d(x1) = [0] x1 + [0]
u(x1) = [0] x1 + [0]
b(x1) = [0] x1 + [0]
v(x1) = [0] x1 + [0]
w(x1) = [0] x1 + [0]
a^#(x1) = [0] x1 + [0]
c_0() = [0]
u^#(x1) = [0] x1 + [0]
c_1() = [0]
v^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4() = [0]
w^#(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7() = [0]
We have applied the subprocessor on the resulting DP-problem:
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {a^#(c(d(x))) -> c_0()}
Weak Rules: {}
Details:
We apply the weight gap principle, strictly orienting the rules
{a^#(c(d(x))) -> c_0()}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{a^#(c(d(x))) -> c_0()}
Details:
Interpretation Functions:
a(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [0]
d(x1) = [1] x1 + [0]
u(x1) = [0] x1 + [0]
b(x1) = [0] x1 + [0]
v(x1) = [0] x1 + [0]
w(x1) = [0] x1 + [0]
a^#(x1) = [1] x1 + [1]
c_0() = [0]
u^#(x1) = [0] x1 + [0]
c_1() = [0]
v^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4() = [0]
w^#(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
'Empty TRS'
-----------
Answer: YES(?,O(1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {}
Weak Rules: {a^#(c(d(x))) -> c_0()}
Details:
The given problem does not contain any strict rules
10)
{v^#(c(x)) -> c_4()}
The usable rules for this path are empty.
We have oriented the usable rules with the following strongly linear interpretation:
Interpretation Functions:
a(x1) = [0] x1 + [0]
c(x1) = [0] x1 + [0]
d(x1) = [0] x1 + [0]
u(x1) = [0] x1 + [0]
b(x1) = [0] x1 + [0]
v(x1) = [0] x1 + [0]
w(x1) = [0] x1 + [0]
a^#(x1) = [0] x1 + [0]
c_0() = [0]
u^#(x1) = [0] x1 + [0]
c_1() = [0]
v^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4() = [0]
w^#(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7() = [0]
We have applied the subprocessor on the resulting DP-problem:
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {v^#(c(x)) -> c_4()}
Weak Rules: {}
Details:
We apply the weight gap principle, strictly orienting the rules
{v^#(c(x)) -> c_4()}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{v^#(c(x)) -> c_4()}
Details:
Interpretation Functions:
a(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [0]
d(x1) = [0] x1 + [0]
u(x1) = [0] x1 + [0]
b(x1) = [0] x1 + [0]
v(x1) = [0] x1 + [0]
w(x1) = [0] x1 + [0]
a^#(x1) = [0] x1 + [0]
c_0() = [0]
u^#(x1) = [0] x1 + [0]
c_1() = [0]
v^#(x1) = [1] x1 + [1]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4() = [0]
w^#(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
'Empty TRS'
-----------
Answer: YES(?,O(1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {}
Weak Rules: {v^#(c(x)) -> c_4()}
Details:
The given problem does not contain any strict rules
11)
{w^#(c(x)) -> c_7()}
The usable rules for this path are empty.
We have oriented the usable rules with the following strongly linear interpretation:
Interpretation Functions:
a(x1) = [0] x1 + [0]
c(x1) = [0] x1 + [0]
d(x1) = [0] x1 + [0]
u(x1) = [0] x1 + [0]
b(x1) = [0] x1 + [0]
v(x1) = [0] x1 + [0]
w(x1) = [0] x1 + [0]
a^#(x1) = [0] x1 + [0]
c_0() = [0]
u^#(x1) = [0] x1 + [0]
c_1() = [0]
v^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4() = [0]
w^#(x1) = [0] x1 + [0]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7() = [0]
We have applied the subprocessor on the resulting DP-problem:
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {w^#(c(x)) -> c_7()}
Weak Rules: {}
Details:
We apply the weight gap principle, strictly orienting the rules
{w^#(c(x)) -> c_7()}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{w^#(c(x)) -> c_7()}
Details:
Interpretation Functions:
a(x1) = [0] x1 + [0]
c(x1) = [1] x1 + [0]
d(x1) = [0] x1 + [0]
u(x1) = [0] x1 + [0]
b(x1) = [0] x1 + [0]
v(x1) = [0] x1 + [0]
w(x1) = [0] x1 + [0]
a^#(x1) = [0] x1 + [0]
c_0() = [0]
u^#(x1) = [0] x1 + [0]
c_1() = [0]
v^#(x1) = [0] x1 + [0]
c_2(x1) = [0] x1 + [0]
c_3(x1) = [0] x1 + [0]
c_4() = [0]
w^#(x1) = [1] x1 + [1]
c_5(x1) = [0] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
'Empty TRS'
-----------
Answer: YES(?,O(1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {}
Weak Rules: {w^#(c(x)) -> c_7()}
Details:
The given problem does not contain any strict rules